package com.tianshi.agriculture.utils.ModbusUtils;

//import org.htmlparser.util.sort.Ordered;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;

public class ByteUtil {

    public static ByteOrder DefaultByteOrder = ByteOrder.BIG_ENDIAN;

    public static String toHexString(byte[] input, String separator) {
        if (input==null) return null;

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < input.length; i++) {
            if (separator != null && sb.length() > 0) {
                sb.append(separator);
            }
            String str = Integer.toHexString(input[i] & 0xff);
            if (str.length() == 1) str = "0" + str;
            sb.append(str);
        }
        return sb.toString();
    }

    public static String toHexString(byte[] input) {
        return toHexString(input, " ");
    }

    public static byte[] fromInt32(int input){
        byte[] result=new byte[4];
        result[3]=(byte)(input >> 24 & 0xFF);
        result[2]=(byte)(input >> 16 & 0xFF);
        result[1]=(byte)(input >> 8 & 0xFF);
        result[0]=(byte)(input & 0xFF);
        return result;
    }

    public static byte[] fromInt32Reverse(int input){
        byte[] result=new byte[4];
        result[0]=(byte)(input >> 24 & 0xFF);
        result[1]=(byte)(input >> 16 & 0xFF);
        result[2]=(byte)(input >> 8 & 0xFF);
        result[3]=(byte)(input & 0xFF);
        return result;
    }

    public static byte[] fromInt16(int input){
        byte[] result=new byte[2];
        result[0]=(byte)(input >> 8 & 0xFF);
        result[1]=(byte)(input & 0xFF);
        return result;
    }

    public static byte[] fromInt16Reversal(int input){
        byte[] result=new byte[2];
        result[1]=(byte)(input>>8&0xFF);
        result[0]=(byte)(input&0xFF);
        return result;
    }

    public static short bytesToInt16(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.allocate(2);
        buffer.order(DefaultByteOrder);
        buffer.put(bytes);
        buffer.flip();
        return buffer.getShort();
    }

    public static short bytesToInt16(byte byte1,byte byte2) {
        byte[] bytes = new byte[2];
        bytes[0] = byte1;
        bytes[1] = byte2;
        return bytesToInt16(bytes);
    }


    // 将 uint16 转换为 byte 数组
    public static byte[] int16ToBytes(short value) {
        ByteBuffer buffer = ByteBuffer.allocate(2);
        buffer.order(DefaultByteOrder);
        buffer.putShort(value);
        return buffer.array();
    }

    // 将 byte[] 转换为 int32
    public static int bytesToInt32(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.order(DefaultByteOrder);
        buffer.put(bytes);
        buffer.flip();
        return buffer.getInt();
    }

    public static long bytesToInt64(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.allocate(8);
        buffer.order(DefaultByteOrder);
        buffer.put(bytes);
        buffer.flip();
        return buffer.getLong();
    }

    public static int bytesToInt32(byte byte1,byte byte2,byte byte3,byte byte4) {
        byte[] bytes = new byte[4];
        bytes[0] = byte1;
        bytes[1] = byte2;
        bytes[2] = byte3;
        bytes[3] = byte4;
        return bytesToInt32(bytes);
    }

    // 将 int32 转换为 byte[]
    public static byte[] int32ToBytes(int int32) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.order(DefaultByteOrder);
        buffer.putInt(int32);
        return buffer.array();
    }

    public static int bytesToUint16(byte byte1,byte byte2) {
        byte[] bytes = new byte[4];
        bytes[0] = 0;
        bytes[1] = 0;
        bytes[2] = byte1;
        bytes[3] = byte2;
        int uint16_or_int32 = ByteUtil.bytesToInt32(bytes);
        return uint16_or_int32;
    }


    public static long bytesToUint32(byte byte1,byte byte2,byte byte3,byte byte4) {
        byte[] buffers = new byte[4];
        buffers[0] = byte1;
        buffers[1] = byte2;
        buffers[2] = byte3;
        buffers[3] = byte4;

        return bytesToUint32(buffers);
    }

    // 将 byte 数组转换为 uint32
    public static long bytesToUint32(byte[] oldBytes) {
        byte[] buffers = new byte[8];
        buffers[0] = 0;
        buffers[1] = 0;
        buffers[2] = 0;
        buffers[3] = 0;
        buffers[4] = oldBytes[0];
        buffers[5] = oldBytes[1];
        buffers[6] = oldBytes[2];
        buffers[7] = oldBytes[3];

        long uint32_or_int64 = ByteUtil.bytesToInt64(buffers);
        return uint32_or_int64;
    }

    // 将 byte 数组转换为 float (4个字节)
    public static float bytesToFloat(byte byte1, byte byte2, byte byte3, byte byte4) {
        byte[] bytes = new byte[4];
        bytes[0] = byte1;
        bytes[1] = byte2;
        bytes[2] = byte3;
        bytes[3] = byte4;
        return bytesToFloat(bytes);
    }

    // 将 byte 数组转换为 float
    public static float bytesToFloat(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.order(DefaultByteOrder);
        buffer.put(bytes);
        buffer.flip();
        return buffer.getFloat();
    }

    // 将 float 转换为 byte 数组
    public static byte[] floatToBytes(float value) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.order(DefaultByteOrder);
        buffer.putFloat(value);
        return buffer.array();
    }
}
